// Code generated by protoc-gen-go. DO NOT EDIT.
// source: protos/sharding_rules.proto

package proto

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type ShardingRuleEntry struct {
	Column               string   `protobuf:"bytes,2,opt,name=column,proto3" json:"column,omitempty"`
	HashFunction         string   `protobuf:"bytes,3,opt,name=hashFunction,proto3" json:"hashFunction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShardingRuleEntry) Reset()         { *m = ShardingRuleEntry{} }
func (m *ShardingRuleEntry) String() string { return proto.CompactTextString(m) }
func (*ShardingRuleEntry) ProtoMessage()    {}
func (*ShardingRuleEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{0}
}

func (m *ShardingRuleEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShardingRuleEntry.Unmarshal(m, b)
}
func (m *ShardingRuleEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShardingRuleEntry.Marshal(b, m, deterministic)
}
func (m *ShardingRuleEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardingRuleEntry.Merge(m, src)
}
func (m *ShardingRuleEntry) XXX_Size() int {
	return xxx_messageInfo_ShardingRuleEntry.Size(m)
}
func (m *ShardingRuleEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardingRuleEntry.DiscardUnknown(m)
}

var xxx_messageInfo_ShardingRuleEntry proto.InternalMessageInfo

func (m *ShardingRuleEntry) GetColumn() string {
	if m != nil {
		return m.Column
	}
	return ""
}

func (m *ShardingRuleEntry) GetHashFunction() string {
	if m != nil {
		return m.HashFunction
	}
	return ""
}

type ShardingRule struct {
	Id                   string               `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	TableName            string               `protobuf:"bytes,2,opt,name=tableName,proto3" json:"tableName,omitempty"`
	ShardingRuleEntry    []*ShardingRuleEntry `protobuf:"bytes,3,rep,name=ShardingRuleEntry,proto3" json:"ShardingRuleEntry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ShardingRule) Reset()         { *m = ShardingRule{} }
func (m *ShardingRule) String() string { return proto.CompactTextString(m) }
func (*ShardingRule) ProtoMessage()    {}
func (*ShardingRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{1}
}

func (m *ShardingRule) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShardingRule.Unmarshal(m, b)
}
func (m *ShardingRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShardingRule.Marshal(b, m, deterministic)
}
func (m *ShardingRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardingRule.Merge(m, src)
}
func (m *ShardingRule) XXX_Size() int {
	return xxx_messageInfo_ShardingRule.Size(m)
}
func (m *ShardingRule) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardingRule.DiscardUnknown(m)
}

var xxx_messageInfo_ShardingRule proto.InternalMessageInfo

func (m *ShardingRule) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ShardingRule) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *ShardingRule) GetShardingRuleEntry() []*ShardingRuleEntry {
	if m != nil {
		return m.ShardingRuleEntry
	}
	return nil
}

type AddShardingRuleRequest struct {
	Rules                []*ShardingRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AddShardingRuleRequest) Reset()         { *m = AddShardingRuleRequest{} }
func (m *AddShardingRuleRequest) String() string { return proto.CompactTextString(m) }
func (*AddShardingRuleRequest) ProtoMessage()    {}
func (*AddShardingRuleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{2}
}

func (m *AddShardingRuleRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AddShardingRuleRequest.Unmarshal(m, b)
}
func (m *AddShardingRuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AddShardingRuleRequest.Marshal(b, m, deterministic)
}
func (m *AddShardingRuleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddShardingRuleRequest.Merge(m, src)
}
func (m *AddShardingRuleRequest) XXX_Size() int {
	return xxx_messageInfo_AddShardingRuleRequest.Size(m)
}
func (m *AddShardingRuleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddShardingRuleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddShardingRuleRequest proto.InternalMessageInfo

func (m *AddShardingRuleRequest) GetRules() []*ShardingRule {
	if m != nil {
		return m.Rules
	}
	return nil
}

type AddShardingRuleReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddShardingRuleReply) Reset()         { *m = AddShardingRuleReply{} }
func (m *AddShardingRuleReply) String() string { return proto.CompactTextString(m) }
func (*AddShardingRuleReply) ProtoMessage()    {}
func (*AddShardingRuleReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{3}
}

func (m *AddShardingRuleReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AddShardingRuleReply.Unmarshal(m, b)
}
func (m *AddShardingRuleReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AddShardingRuleReply.Marshal(b, m, deterministic)
}
func (m *AddShardingRuleReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddShardingRuleReply.Merge(m, src)
}
func (m *AddShardingRuleReply) XXX_Size() int {
	return xxx_messageInfo_AddShardingRuleReply.Size(m)
}
func (m *AddShardingRuleReply) XXX_DiscardUnknown() {
	xxx_messageInfo_AddShardingRuleReply.DiscardUnknown(m)
}

var xxx_messageInfo_AddShardingRuleReply proto.InternalMessageInfo

type ListShardingRuleRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListShardingRuleRequest) Reset()         { *m = ListShardingRuleRequest{} }
func (m *ListShardingRuleRequest) String() string { return proto.CompactTextString(m) }
func (*ListShardingRuleRequest) ProtoMessage()    {}
func (*ListShardingRuleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{4}
}

func (m *ListShardingRuleRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListShardingRuleRequest.Unmarshal(m, b)
}
func (m *ListShardingRuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListShardingRuleRequest.Marshal(b, m, deterministic)
}
func (m *ListShardingRuleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListShardingRuleRequest.Merge(m, src)
}
func (m *ListShardingRuleRequest) XXX_Size() int {
	return xxx_messageInfo_ListShardingRuleRequest.Size(m)
}
func (m *ListShardingRuleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListShardingRuleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListShardingRuleRequest proto.InternalMessageInfo

type ListShardingRuleReply struct {
	Rules                []*ShardingRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ListShardingRuleReply) Reset()         { *m = ListShardingRuleReply{} }
func (m *ListShardingRuleReply) String() string { return proto.CompactTextString(m) }
func (*ListShardingRuleReply) ProtoMessage()    {}
func (*ListShardingRuleReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{5}
}

func (m *ListShardingRuleReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListShardingRuleReply.Unmarshal(m, b)
}
func (m *ListShardingRuleReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListShardingRuleReply.Marshal(b, m, deterministic)
}
func (m *ListShardingRuleReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListShardingRuleReply.Merge(m, src)
}
func (m *ListShardingRuleReply) XXX_Size() int {
	return xxx_messageInfo_ListShardingRuleReply.Size(m)
}
func (m *ListShardingRuleReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ListShardingRuleReply.DiscardUnknown(m)
}

var xxx_messageInfo_ListShardingRuleReply proto.InternalMessageInfo

func (m *ListShardingRuleReply) GetRules() []*ShardingRule {
	if m != nil {
		return m.Rules
	}
	return nil
}

type DropShardingRuleRequest struct {
	Id                   []string `protobuf:"bytes,1,rep,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DropShardingRuleRequest) Reset()         { *m = DropShardingRuleRequest{} }
func (m *DropShardingRuleRequest) String() string { return proto.CompactTextString(m) }
func (*DropShardingRuleRequest) ProtoMessage()    {}
func (*DropShardingRuleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{6}
}

func (m *DropShardingRuleRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DropShardingRuleRequest.Unmarshal(m, b)
}
func (m *DropShardingRuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DropShardingRuleRequest.Marshal(b, m, deterministic)
}
func (m *DropShardingRuleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DropShardingRuleRequest.Merge(m, src)
}
func (m *DropShardingRuleRequest) XXX_Size() int {
	return xxx_messageInfo_DropShardingRuleRequest.Size(m)
}
func (m *DropShardingRuleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DropShardingRuleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DropShardingRuleRequest proto.InternalMessageInfo

func (m *DropShardingRuleRequest) GetId() []string {
	if m != nil {
		return m.Id
	}
	return nil
}

type DropShardingRuleReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DropShardingRuleReply) Reset()         { *m = DropShardingRuleReply{} }
func (m *DropShardingRuleReply) String() string { return proto.CompactTextString(m) }
func (*DropShardingRuleReply) ProtoMessage()    {}
func (*DropShardingRuleReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_b2011e1e95c68234, []int{7}
}

func (m *DropShardingRuleReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DropShardingRuleReply.Unmarshal(m, b)
}
func (m *DropShardingRuleReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DropShardingRuleReply.Marshal(b, m, deterministic)
}
func (m *DropShardingRuleReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DropShardingRuleReply.Merge(m, src)
}
func (m *DropShardingRuleReply) XXX_Size() int {
	return xxx_messageInfo_DropShardingRuleReply.Size(m)
}
func (m *DropShardingRuleReply) XXX_DiscardUnknown() {
	xxx_messageInfo_DropShardingRuleReply.DiscardUnknown(m)
}

var xxx_messageInfo_DropShardingRuleReply proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ShardingRuleEntry)(nil), "spqr.ShardingRuleEntry")
	proto.RegisterType((*ShardingRule)(nil), "spqr.ShardingRule")
	proto.RegisterType((*AddShardingRuleRequest)(nil), "spqr.AddShardingRuleRequest")
	proto.RegisterType((*AddShardingRuleReply)(nil), "spqr.AddShardingRuleReply")
	proto.RegisterType((*ListShardingRuleRequest)(nil), "spqr.ListShardingRuleRequest")
	proto.RegisterType((*ListShardingRuleReply)(nil), "spqr.ListShardingRuleReply")
	proto.RegisterType((*DropShardingRuleRequest)(nil), "spqr.DropShardingRuleRequest")
	proto.RegisterType((*DropShardingRuleReply)(nil), "spqr.DropShardingRuleReply")
}

func init() { proto.RegisterFile("protos/sharding_rules.proto", fileDescriptor_b2011e1e95c68234) }

var fileDescriptor_b2011e1e95c68234 = []byte{
	// 332 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x41, 0x4f, 0xc2, 0x40,
	0x10, 0x85, 0x69, 0xab, 0x24, 0x8c, 0xc4, 0xc8, 0x04, 0x68, 0x05, 0x4c, 0xc8, 0x9e, 0xf0, 0x02,
	0x09, 0xfe, 0x02, 0x88, 0x78, 0x32, 0x18, 0xcb, 0xcd, 0x8b, 0x29, 0x74, 0x23, 0x4d, 0x96, 0x76,
	0xd9, 0xdd, 0x9a, 0xf4, 0xec, 0xd5, 0x1f, 0x6d, 0xd8, 0x02, 0x22, 0xdb, 0x1e, 0x3c, 0x35, 0x7d,
	0x6f, 0xe6, 0xeb, 0x9b, 0x97, 0x42, 0x97, 0x8b, 0x44, 0x25, 0x72, 0x24, 0xd7, 0x81, 0x08, 0xa3,
	0xf8, 0xe3, 0x5d, 0xa4, 0x8c, 0xca, 0xa1, 0x56, 0xf1, 0x42, 0xf2, 0xad, 0x20, 0x2f, 0xd0, 0x58,
	0xec, 0x5d, 0x3f, 0x65, 0x74, 0x16, 0x2b, 0x91, 0x61, 0x1b, 0xaa, 0xab, 0x84, 0xa5, 0x9b, 0xd8,
	0xb3, 0xfb, 0xd6, 0xa0, 0xe6, 0xef, 0xdf, 0x90, 0x40, 0x7d, 0x1d, 0xc8, 0xf5, 0x53, 0x1a, 0xaf,
	0x54, 0x94, 0xc4, 0x9e, 0xa3, 0xdd, 0x3f, 0x1a, 0xf9, 0xb2, 0xa0, 0x7e, 0x4a, 0xc4, 0x6b, 0xb0,
	0xa3, 0xd0, 0xb3, 0xf4, 0xa8, 0x1d, 0x85, 0xd8, 0x83, 0x9a, 0x0a, 0x96, 0x8c, 0xce, 0x83, 0x0d,
	0xdd, 0xf3, 0x7f, 0x05, 0x9c, 0x15, 0xe4, 0xf1, 0x9c, 0xbe, 0x33, 0xb8, 0x1a, 0xbb, 0xc3, 0x5d,
	0xe2, 0xa1, 0x61, 0xfb, 0xe6, 0x06, 0x99, 0x42, 0x7b, 0x12, 0x86, 0xa7, 0xba, 0x4f, 0xb7, 0x29,
	0x95, 0x0a, 0x07, 0x70, 0xa9, 0x5b, 0xf0, 0x2c, 0x0d, 0x45, 0x13, 0xea, 0xe7, 0x03, 0xa4, 0x0d,
	0x4d, 0x83, 0xc1, 0x59, 0x46, 0x6e, 0xc1, 0x7d, 0x8e, 0xa4, 0x2a, 0x80, 0x93, 0x09, 0xb4, 0x4c,
	0x8b, 0xb3, 0xec, 0x1f, 0x5f, 0xbd, 0x07, 0xf7, 0x51, 0x24, 0xbc, 0x28, 0xfa, 0xa1, 0x49, 0x27,
	0x6f, 0x92, 0xb8, 0xd0, 0x32, 0x47, 0x39, 0xcb, 0xc6, 0xdf, 0x36, 0x34, 0x4f, 0x55, 0xb9, 0xa0,
	0xe2, 0x33, 0x5a, 0x51, 0x9c, 0xc3, 0xcd, 0xd9, 0x49, 0x12, 0x7b, 0x79, 0x96, 0xe2, 0xba, 0x3a,
	0x9d, 0x12, 0x77, 0x57, 0x44, 0x05, 0x5f, 0xa1, 0x71, 0x9e, 0x40, 0xe2, 0x5d, 0xbe, 0x52, 0x72,
	0x45, 0xa7, 0x5b, 0x66, 0x1f, 0x91, 0xe7, 0x15, 0x1e, 0x91, 0x25, 0xb5, 0x1f, 0x90, 0x85, 0xd5,
	0x93, 0xca, 0xb4, 0xfe, 0x06, 0x3b, 0x7f, 0xa4, 0xff, 0xfb, 0x65, 0x55, 0x3f, 0x1e, 0x7e, 0x02,
	0x00, 0x00, 0xff, 0xff, 0xfa, 0xd1, 0x25, 0xa9, 0x1d, 0x03, 0x00, 0x00,
}
